
struct-yz.o:     file format elf32-littlearm


Disassembly of section .text:

00000000 <test>:
	int c;
	struct tt t;
};

int test(struct tt *ts)
{
   0:	e92d4800 	push	{fp, lr}
   4:	e28db004 	add	fp, sp, #4
   8:	e24dd018 	sub	sp, sp, #24
   c:	e50b0010 	str	r0, [fp, #-16]
//	struct tt *t;
	struct wd *w;
	char *p;
	
	ts->a = 'a';
  10:	e51b3010 	ldr	r3, [fp, #-16]
  14:	e3a02061 	mov	r2, #97	; 0x61
  18:	e5c32000 	strb	r2, [r3]
	ts->private_data = "wiaozhi_1234567890";
  1c:	e51b3010 	ldr	r3, [fp, #-16]
  20:	e59f206c 	ldr	r2, [pc, #108]	; 94 <test+0x94>
  24:	e5832004 	str	r2, [r3, #4]
	
	//w = (struct wd *)t->private_data;
	w = ts->private_data;
  28:	e51b3010 	ldr	r3, [fp, #-16]
  2c:	e5933004 	ldr	r3, [r3, #4]
  30:	e50b3008 	str	r3, [fp, #-8]
	p = ts->private_data;
  34:	e51b3010 	ldr	r3, [fp, #-16]
  38:	e5933004 	ldr	r3, [r3, #4]
  3c:	e50b300c 	str	r3, [fp, #-12]
	
	//							wiao   zhi_ 1234  567890
	//							w      z    1     5      wiaozhi_1234567890
	printf("%c %c %c %c %s\n", w->a, w->b, w->c, w->t.a, p);
  40:	e51b3008 	ldr	r3, [fp, #-8]
  44:	e5d33000 	ldrb	r3, [r3]
  48:	e1a0c003 	mov	ip, r3
  4c:	e51b3008 	ldr	r3, [fp, #-8]
  50:	e5932004 	ldr	r2, [r3, #4]
  54:	e51b3008 	ldr	r3, [fp, #-8]
  58:	e5931008 	ldr	r1, [r3, #8]
  5c:	e51b3008 	ldr	r3, [fp, #-8]
  60:	e5d3300c 	ldrb	r3, [r3, #12]
  64:	e1a00003 	mov	r0, r3
  68:	e51b300c 	ldr	r3, [fp, #-12]
  6c:	e58d3004 	str	r3, [sp, #4]
  70:	e58d0000 	str	r0, [sp]
  74:	e1a03001 	mov	r3, r1
  78:	e1a0100c 	mov	r1, ip
  7c:	e59f0014 	ldr	r0, [pc, #20]	; 98 <test+0x98>
  80:	ebfffffe 	bl	0 <printf>
	
	return 0;
  84:	e3a03000 	mov	r3, #0
}
  88:	e1a00003 	mov	r0, r3
  8c:	e24bd004 	sub	sp, fp, #4
  90:	e8bd8800 	pop	{fp, pc}
  94:	00000000 	.word	0x00000000
  98:	00000014 	.word	0x00000014

0000009c <f>:

int (*pf)(void);

int f(void)
{
  9c:	e92d4800 	push	{fp, lr}
  a0:	e28db004 	add	fp, sp, #4
	printf("================= wise\n");
  a4:	e59f000c 	ldr	r0, [pc, #12]	; b8 <f+0x1c>
  a8:	ebfffffe 	bl	0 <puts>
	return 1;
  ac:	e3a03001 	mov	r3, #1
}
  b0:	e1a00003 	mov	r0, r3
  b4:	e8bd8800 	pop	{fp, pc}
  b8:	00000024 	.word	0x00000024

000000bc <test_pf>:

void test_pf()
{
  bc:	e92d4800 	push	{fp, lr}
  c0:	e28db004 	add	fp, sp, #4
	pf = &f;
  c4:	e59f3030 	ldr	r3, [pc, #48]	; fc <test_pf+0x40>
  c8:	e59f2030 	ldr	r2, [pc, #48]	; 100 <test_pf+0x44>
  cc:	e5832000 	str	r2, [r3]
	pf();
  d0:	e59f3024 	ldr	r3, [pc, #36]	; fc <test_pf+0x40>
  d4:	e5933000 	ldr	r3, [r3]
  d8:	e12fff33 	blx	r3
	pf = ****f;
  dc:	e59f3018 	ldr	r3, [pc, #24]	; fc <test_pf+0x40>
  e0:	e59f2018 	ldr	r2, [pc, #24]	; 100 <test_pf+0x44>
  e4:	e5832000 	str	r2, [r3]
	pf();
  e8:	e59f300c 	ldr	r3, [pc, #12]	; fc <test_pf+0x40>
  ec:	e5933000 	ldr	r3, [r3]
  f0:	e12fff33 	blx	r3
	(***************************************************f)();
  f4:	ebfffffe 	bl	9c <f>
}
  f8:	e8bd8800 	pop	{fp, pc}
	...

00000104 <re>:
int re()
{
 104:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
 108:	e28db000 	add	fp, sp, #0
 10c:	e24dd014 	sub	sp, sp, #20
	return ((int []){1,2,3,4})[3];
 110:	e59f301c 	ldr	r3, [pc, #28]	; 134 <re+0x30>
 114:	e24bc014 	sub	ip, fp, #20
 118:	e893000f 	ldm	r3, {r0, r1, r2, r3}
 11c:	e88c000f 	stm	ip, {r0, r1, r2, r3}
 120:	e51b3008 	ldr	r3, [fp, #-8]
}
 124:	e1a00003 	mov	r0, r3
 128:	e24bd000 	sub	sp, fp, #0
 12c:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
 130:	e12fff1e 	bx	lr
 134:	0000003c 	.word	0x0000003c

00000138 <foo>:

unsigned long foo()
{
 138:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
 13c:	e28db000 	add	fp, sp, #0
	return (unsigned long) - 1 / 8;		// 536870911
 140:	e3e0320e 	mvn	r3, #-536870912	; 0xe0000000
}
 144:	e1a00003 	mov	r0, r3
 148:	e24bd000 	sub	sp, fp, #0
 14c:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
 150:	e12fff1e 	bx	lr

00000154 <foo2>:

unsigned long foo2()
{
 154:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
 158:	e28db000 	add	fp, sp, #0
	return ((unsigned long) - 1) / 8;	// 536870911
 15c:	e3e0320e 	mvn	r3, #-536870912	; 0xe0000000
}
 160:	e1a00003 	mov	r0, r3
 164:	e24bd000 	sub	sp, fp, #0
 168:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
 16c:	e12fff1e 	bx	lr

00000170 <foo3>:

unsigned long foo3()
{
 170:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
 174:	e28db000 	add	fp, sp, #0
	return (unsigned long) (-1 / 8);	// 0
 178:	e3a03000 	mov	r3, #0
}
 17c:	e1a00003 	mov	r0, r3
 180:	e24bd000 	sub	sp, fp, #0
 184:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
 188:	e12fff1e 	bx	lr

0000018c <T>:
				((char *)&((T3) {1, (char *) 1}))
			}
		};
		
int T()
{
 18c:	e92d4810 	push	{r4, fp, lr}
 190:	e28db008 	add	fp, sp, #8
 194:	e24dd02c 	sub	sp, sp, #44	; 0x2c
	T3 *pt3 = (T3*)a[0].value;
 198:	e59f3080 	ldr	r3, [pc, #128]	; 220 <T+0x94>
 19c:	e5933004 	ldr	r3, [r3, #4]
 1a0:	e50b3010 	str	r3, [fp, #-16]
	int value;
	char *b = "xiaozhi";
 1a4:	e59f3078 	ldr	r3, [pc, #120]	; 224 <T+0x98>
 1a8:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
	char c[] = {'a', 'b', 'c', 'd', 'e', 'f'};
 1ac:	e59f2074 	ldr	r2, [pc, #116]	; 228 <T+0x9c>
 1b0:	e24b3020 	sub	r3, fp, #32
 1b4:	e1a01002 	mov	r1, r2
 1b8:	e3a02006 	mov	r2, #6
 1bc:	e1a00003 	mov	r0, r3
 1c0:	ebfffffe 	bl	0 <memcpy>
	
	value = sizeof(a);
 1c4:	e3a03008 	mov	r3, #8
 1c8:	e50b3018 	str	r3, [fp, #-24]	; 0xffffffe8
	printf("T() : %d %d %d %d sizeof c=%d strlen c=%d\n", 
 1cc:	e51b0014 	ldr	r0, [fp, #-20]	; 0xffffffec
 1d0:	ebfffffe 	bl	0 <strlen>
 1d4:	e1a04000 	mov	r4, r0
 1d8:	e24b3020 	sub	r3, fp, #32
 1dc:	e1a00003 	mov	r0, r3
 1e0:	ebfffffe 	bl	0 <strlen>
 1e4:	e1a03000 	mov	r3, r0
 1e8:	e58d3008 	str	r3, [sp, #8]
 1ec:	e3a03006 	mov	r3, #6
 1f0:	e58d3004 	str	r3, [sp, #4]
 1f4:	e58d4000 	str	r4, [sp]
 1f8:	e3a03004 	mov	r3, #4
 1fc:	e3a02004 	mov	r2, #4
 200:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
 204:	e59f0020 	ldr	r0, [pc, #32]	; 22c <T+0xa0>
 208:	ebfffffe 	bl	0 <printf>
					 value, sizeof(long),
					 sizeof(b), strlen(b), 
					 sizeof(c), strlen(c));
	return (int)pt3->value;
 20c:	e51b3010 	ldr	r3, [fp, #-16]
 210:	e5933004 	ldr	r3, [r3, #4]
}
 214:	e1a00003 	mov	r0, r3
 218:	e24bd008 	sub	sp, fp, #8
 21c:	e8bd8810 	pop	{r4, fp, pc}
 220:	00000000 	.word	0x00000000
 224:	00000050 	.word	0x00000050
 228:	00000084 	.word	0x00000084
 22c:	00000058 	.word	0x00000058

00000230 <fxxx>:
/********************************************************************/

int xxx = 7;
int fxxx()
{
 230:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
 234:	e28db000 	add	fp, sp, #0
 238:	e24dd00c 	sub	sp, sp, #12
	int xxx = 3;
 23c:	e3a03003 	mov	r3, #3
 240:	e50b3008 	str	r3, [fp, #-8]
	{
		extern int xxx;
		return xxx;
 244:	e59f3010 	ldr	r3, [pc, #16]	; 25c <fxxx+0x2c>
 248:	e5933000 	ldr	r3, [r3]
	}
}
 24c:	e1a00003 	mov	r0, r3
 250:	e24bd000 	sub	sp, fp, #0
 254:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
 258:	e12fff1e 	bx	lr
 25c:	00000000 	.word	0x00000000

00000260 <iii>:

int iii()
{
 260:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
 264:	e28db000 	add	fp, sp, #0
	return (unsigned long)((1 - sizeof(int)) >> 31);
 268:	e3a03001 	mov	r3, #1
}
 26c:	e1a00003 	mov	r0, r3
 270:	e24bd000 	sub	sp, fp, #0
 274:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
 278:	e12fff1e 	bx	lr

0000027c <print_ix>:
		int y, z;
	}nested;
} ix = { .nested.y = 5, 6, .x = 1, 2};

void print_ix()
{
 27c:	e92d4800 	push	{fp, lr}
 280:	e28db004 	add	fp, sp, #4
	printf("ix.nested.y = %d, ix.nested.x = %d, ix.x = %d\n", ix.nested.y, ix.nested.z, 0);
 284:	e59f3018 	ldr	r3, [pc, #24]	; 2a4 <print_ix+0x28>
 288:	e5931004 	ldr	r1, [r3, #4]
 28c:	e59f3010 	ldr	r3, [pc, #16]	; 2a4 <print_ix+0x28>
 290:	e5932008 	ldr	r2, [r3, #8]
 294:	e3a03000 	mov	r3, #0
 298:	e59f0008 	ldr	r0, [pc, #8]	; 2a8 <print_ix+0x2c>
 29c:	ebfffffe 	bl	0 <printf>
}
 2a0:	e8bd8800 	pop	{fp, pc}
 2a4:	00000000 	.word	0x00000000
 2a8:	0000008c 	.word	0x0000008c

000002ac <invoke>:

void invoke()
{
 2ac:	e92d4800 	push	{fp, lr}
 2b0:	e28db004 	add	fp, sp, #4
	printf("invoke re   ======== %d\n",  re());
 2b4:	ebfffffe 	bl	104 <re>
 2b8:	e1a03000 	mov	r3, r0
 2bc:	e1a01003 	mov	r1, r3
 2c0:	e59f0080 	ldr	r0, [pc, #128]	; 348 <invoke+0x9c>
 2c4:	ebfffffe 	bl	0 <printf>
	printf("invoke foo  ======== %ld\n", foo());
 2c8:	ebfffffe 	bl	138 <foo>
 2cc:	e1a03000 	mov	r3, r0
 2d0:	e1a01003 	mov	r1, r3
 2d4:	e59f0070 	ldr	r0, [pc, #112]	; 34c <invoke+0xa0>
 2d8:	ebfffffe 	bl	0 <printf>
	printf("invoke foo2 ======== %ld\n", foo2());
 2dc:	ebfffffe 	bl	154 <foo2>
 2e0:	e1a03000 	mov	r3, r0
 2e4:	e1a01003 	mov	r1, r3
 2e8:	e59f0060 	ldr	r0, [pc, #96]	; 350 <invoke+0xa4>
 2ec:	ebfffffe 	bl	0 <printf>
	printf("invoke foo3 ======== %ld\n", foo3());
 2f0:	ebfffffe 	bl	170 <foo3>
 2f4:	e1a03000 	mov	r3, r0
 2f8:	e1a01003 	mov	r1, r3
 2fc:	e59f0050 	ldr	r0, [pc, #80]	; 354 <invoke+0xa8>
 300:	ebfffffe 	bl	0 <printf>
	printf("invoke T    ======== %d\n", T());
 304:	ebfffffe 	bl	18c <T>
 308:	e1a03000 	mov	r3, r0
 30c:	e1a01003 	mov	r1, r3
 310:	e59f0040 	ldr	r0, [pc, #64]	; 358 <invoke+0xac>
 314:	ebfffffe 	bl	0 <printf>
	printf("invoke iii    ======== %d\n", iii());
 318:	ebfffffe 	bl	260 <iii>
 31c:	e1a03000 	mov	r3, r0
 320:	e1a01003 	mov	r1, r3
 324:	e59f0030 	ldr	r0, [pc, #48]	; 35c <invoke+0xb0>
 328:	ebfffffe 	bl	0 <printf>
	printf("invoke fxxx    ======== %d\n", fxxx());
 32c:	ebfffffe 	bl	230 <fxxx>
 330:	e1a03000 	mov	r3, r0
 334:	e1a01003 	mov	r1, r3
 338:	e59f0020 	ldr	r0, [pc, #32]	; 360 <invoke+0xb4>
 33c:	ebfffffe 	bl	0 <printf>
	print_ix();
 340:	ebfffffe 	bl	27c <print_ix>
}
 344:	e8bd8800 	pop	{fp, pc}
 348:	000000bc 	.word	0x000000bc
 34c:	000000d8 	.word	0x000000d8
 350:	000000f4 	.word	0x000000f4
 354:	00000110 	.word	0x00000110
 358:	0000012c 	.word	0x0000012c
 35c:	00000148 	.word	0x00000148
 360:	00000164 	.word	0x00000164

00000364 <saaa>:

int saaa()
{
 364:	e92d4800 	push	{fp, lr}
 368:	e28db004 	add	fp, sp, #4
 36c:	e24dd020 	sub	sp, sp, #32
	struct tt t;
	struct wd w;
	int value;
	
	test(&t);
 370:	e24b300c 	sub	r3, fp, #12
 374:	e1a00003 	mov	r0, r3
 378:	ebfffffe 	bl	0 <test>
	test_pf();
 37c:	ebfffffe 	bl	bc <test_pf>
	(***************************test_pf)();
 380:	ebfffffe 	bl	bc <test_pf>
	invoke();
 384:	ebfffffe 	bl	2ac <invoke>
	
	return 0;
 388:	e3a03000 	mov	r3, #0
}
 38c:	e1a00003 	mov	r0, r3
 390:	e24bd004 	sub	sp, fp, #4
 394:	e8bd8800 	pop	{fp, pc}

00000398 <sbbb>:
	short flag;
	dataset data[6];
}frame;

int sbbb(void)
{
 398:	e92d4800 	push	{fp, lr}
 39c:	e28db004 	add	fp, sp, #4
 3a0:	e24dd0e8 	sub	sp, sp, #232	; 0xe8
	int i, j, k;
	char *ptr;
	
	frame *pfr;
	
	printf("struct size %d\n", sizeof(pfr));
 3a4:	e3a01004 	mov	r1, #4
 3a8:	e59f01ac 	ldr	r0, [pc, #428]	; 55c <sbbb+0x1c4>
 3ac:	ebfffffe 	bl	0 <printf>
	
	for (i = 0; i < 100; i++) {
 3b0:	e3a03000 	mov	r3, #0
 3b4:	e50b3008 	str	r3, [fp, #-8]
 3b8:	ea00000b 	b	3ec <sbbb+0x54>
		data[i] = i + 1;
 3bc:	e51b3008 	ldr	r3, [fp, #-8]
 3c0:	e20330ff 	and	r3, r3, #255	; 0xff
 3c4:	e2833001 	add	r3, r3, #1
 3c8:	e20310ff 	and	r1, r3, #255	; 0xff
 3cc:	e24b20ec 	sub	r2, fp, #236	; 0xec
 3d0:	e51b3008 	ldr	r3, [fp, #-8]
 3d4:	e0823003 	add	r3, r2, r3
 3d8:	e1a02001 	mov	r2, r1
 3dc:	e5c32000 	strb	r2, [r3]
	
	frame *pfr;
	
	printf("struct size %d\n", sizeof(pfr));
	
	for (i = 0; i < 100; i++) {
 3e0:	e51b3008 	ldr	r3, [fp, #-8]
 3e4:	e2833001 	add	r3, r3, #1
 3e8:	e50b3008 	str	r3, [fp, #-8]
 3ec:	e51b3008 	ldr	r3, [fp, #-8]
 3f0:	e3530063 	cmp	r3, #99	; 0x63
 3f4:	dafffff0 	ble	3bc <sbbb+0x24>
		data[i] = i + 1;
	}
	
	k = 0;
 3f8:	e3a03000 	mov	r3, #0
 3fc:	e50b3010 	str	r3, [fp, #-16]
	for (i = 0; i < 6; i++) {
 400:	e3a03000 	mov	r3, #0
 404:	e50b3008 	str	r3, [fp, #-8]
 408:	ea00001e 	b	488 <sbbb+0xf0>
		for (j = 0; j < 16; j++) {
 40c:	e3a03000 	mov	r3, #0
 410:	e50b300c 	str	r3, [fp, #-12]
 414:	ea000015 	b	470 <sbbb+0xd8>
			ft.data[i].data[j] = data[k];
 418:	e24b20ec 	sub	r2, fp, #236	; 0xec
 41c:	e51b3010 	ldr	r3, [fp, #-16]
 420:	e0823003 	add	r3, r2, r3
 424:	e5d31000 	ldrb	r1, [r3]
 428:	e51b2008 	ldr	r2, [fp, #-8]
 42c:	e1a03002 	mov	r3, r2
 430:	e1a03183 	lsl	r3, r3, #3
 434:	e0833002 	add	r3, r3, r2
 438:	e1a03083 	lsl	r3, r3, #1
 43c:	e24b2004 	sub	r2, fp, #4
 440:	e0822003 	add	r2, r2, r3
 444:	e51b300c 	ldr	r3, [fp, #-12]
 448:	e0823003 	add	r3, r2, r3
 44c:	e2433084 	sub	r3, r3, #132	; 0x84
 450:	e1a02001 	mov	r2, r1
 454:	e5c32002 	strb	r2, [r3, #2]
			k++;
 458:	e51b3010 	ldr	r3, [fp, #-16]
 45c:	e2833001 	add	r3, r3, #1
 460:	e50b3010 	str	r3, [fp, #-16]
		data[i] = i + 1;
	}
	
	k = 0;
	for (i = 0; i < 6; i++) {
		for (j = 0; j < 16; j++) {
 464:	e51b300c 	ldr	r3, [fp, #-12]
 468:	e2833001 	add	r3, r3, #1
 46c:	e50b300c 	str	r3, [fp, #-12]
 470:	e51b300c 	ldr	r3, [fp, #-12]
 474:	e353000f 	cmp	r3, #15
 478:	daffffe6 	ble	418 <sbbb+0x80>
	for (i = 0; i < 100; i++) {
		data[i] = i + 1;
	}
	
	k = 0;
	for (i = 0; i < 6; i++) {
 47c:	e51b3008 	ldr	r3, [fp, #-8]
 480:	e2833001 	add	r3, r3, #1
 484:	e50b3008 	str	r3, [fp, #-8]
 488:	e51b3008 	ldr	r3, [fp, #-8]
 48c:	e3530005 	cmp	r3, #5
 490:	daffffdd 	ble	40c <sbbb+0x74>
			ft.data[i].data[j] = data[k];
			k++;
		}
	}
	
	ptr = (char *)&ft;
 494:	e24b3088 	sub	r3, fp, #136	; 0x88
 498:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
	for (i = 0; i < 100; i++)
 49c:	e3a03000 	mov	r3, #0
 4a0:	e50b3008 	str	r3, [fp, #-8]
 4a4:	ea000009 	b	4d0 <sbbb+0x138>
		printf("%5d", *ptr++);
 4a8:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
 4ac:	e2832001 	add	r2, r3, #1
 4b0:	e50b2014 	str	r2, [fp, #-20]	; 0xffffffec
 4b4:	e5d33000 	ldrb	r3, [r3]
 4b8:	e1a01003 	mov	r1, r3
 4bc:	e59f009c 	ldr	r0, [pc, #156]	; 560 <sbbb+0x1c8>
 4c0:	ebfffffe 	bl	0 <printf>
			k++;
		}
	}
	
	ptr = (char *)&ft;
	for (i = 0; i < 100; i++)
 4c4:	e51b3008 	ldr	r3, [fp, #-8]
 4c8:	e2833001 	add	r3, r3, #1
 4cc:	e50b3008 	str	r3, [fp, #-8]
 4d0:	e51b3008 	ldr	r3, [fp, #-8]
 4d4:	e3530063 	cmp	r3, #99	; 0x63
 4d8:	dafffff2 	ble	4a8 <sbbb+0x110>
		printf("%5d", *ptr++);
		
	putchar(0xd);
 4dc:	e59f3080 	ldr	r3, [pc, #128]	; 564 <sbbb+0x1cc>
 4e0:	e5933000 	ldr	r3, [r3]
 4e4:	e50b3018 	str	r3, [fp, #-24]	; 0xffffffe8
 4e8:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
 4ec:	e5933048 	ldr	r3, [r3, #72]	; 0x48
 4f0:	e3530000 	cmp	r3, #0
 4f4:	0a000011 	beq	540 <sbbb+0x1a8>
 4f8:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
 4fc:	e5932010 	ldr	r2, [r3, #16]
 500:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
 504:	e593301c 	ldr	r3, [r3, #28]
 508:	e1520003 	cmp	r2, r3
 50c:	2a000007 	bcs	530 <sbbb+0x198>
 510:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
 514:	e5933010 	ldr	r3, [r3, #16]
 518:	e2831001 	add	r1, r3, #1
 51c:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
 520:	e5821010 	str	r1, [r2, #16]
 524:	e3a0200d 	mov	r2, #13
 528:	e5c32000 	strb	r2, [r3]
 52c:	ea000006 	b	54c <sbbb+0x1b4>
 530:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
 534:	e3a0000d 	mov	r0, #13
 538:	ebfffffe 	bl	0 <__fputc_unlocked>
 53c:	ea000002 	b	54c <sbbb+0x1b4>
 540:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
 544:	e3a0000d 	mov	r0, #13
 548:	ebfffffe 	bl	0 <fputc>
		
	return 0;
 54c:	e3a03000 	mov	r3, #0
}
 550:	e1a00003 	mov	r0, r3
 554:	e24bd004 	sub	sp, fp, #4
 558:	e8bd8800 	pop	{fp, pc}
 55c:	00000180 	.word	0x00000180
 560:	00000190 	.word	0x00000190
 564:	00000000 	.word	0x00000000

00000568 <sccc>:
	int count;
	char something[20];
}stu[3] = {{12, 13, "esp"}, {15,16, "sk"}, {17, 18, "we"}};

int sccc()
{
 568:	e92d4800 	push	{fp, lr}
 56c:	e28db004 	add	fp, sp, #4
 570:	e24dd008 	sub	sp, sp, #8
	struct ec *p;
	
	p = stu;
 574:	e59f3064 	ldr	r3, [pc, #100]	; 5e0 <sccc+0x78>
 578:	e50b3008 	str	r3, [fp, #-8]
	//p = (struct ec *) &stu[0].num;
	//printf("%d\n", p);
	//printf("%d\n", p + 1);
	
	p = (struct ec *) &stu[0];
 57c:	e59f305c 	ldr	r3, [pc, #92]	; 5e0 <sccc+0x78>
 580:	e50b3008 	str	r3, [fp, #-8]
	printf("%d\t%d\t%s\n", p->num, p->count, p->something);
 584:	e51b3008 	ldr	r3, [fp, #-8]
 588:	e5931000 	ldr	r1, [r3]
 58c:	e51b3008 	ldr	r3, [fp, #-8]
 590:	e5932004 	ldr	r2, [r3, #4]
 594:	e51b3008 	ldr	r3, [fp, #-8]
 598:	e2833008 	add	r3, r3, #8
 59c:	e59f0040 	ldr	r0, [pc, #64]	; 5e4 <sccc+0x7c>
 5a0:	ebfffffe 	bl	0 <printf>
	printf("%d\t%d\t%s\n", (p+1)->num, (p+1)->count, (p+1)->something);
 5a4:	e51b3008 	ldr	r3, [fp, #-8]
 5a8:	e283301c 	add	r3, r3, #28
 5ac:	e5931000 	ldr	r1, [r3]
 5b0:	e51b3008 	ldr	r3, [fp, #-8]
 5b4:	e283301c 	add	r3, r3, #28
 5b8:	e5932004 	ldr	r2, [r3, #4]
 5bc:	e51b3008 	ldr	r3, [fp, #-8]
 5c0:	e283301c 	add	r3, r3, #28
 5c4:	e2833008 	add	r3, r3, #8
 5c8:	e59f0014 	ldr	r0, [pc, #20]	; 5e4 <sccc+0x7c>
 5cc:	ebfffffe 	bl	0 <printf>
	
	return 0;
 5d0:	e3a03000 	mov	r3, #0
}
 5d4:	e1a00003 	mov	r0, r3
 5d8:	e24bd004 	sub	sp, fp, #4
 5dc:	e8bd8800 	pop	{fp, pc}
 5e0:	00000000 	.word	0x00000000
 5e4:	00000194 	.word	0x00000194

000005e8 <print>:
}A;

A tmp = {10, '0'};

void print(void)
{
 5e8:	e92d4800 	push	{fp, lr}
 5ec:	e28db004 	add	fp, sp, #4
        printf("tmp.a = %d tmp.b = %c\n", tmp.a, tmp.b);
 5f0:	e59f3040 	ldr	r3, [pc, #64]	; 638 <print+0x50>
 5f4:	e5931000 	ldr	r1, [r3]
 5f8:	e59f3038 	ldr	r3, [pc, #56]	; 638 <print+0x50>
 5fc:	e5d33004 	ldrb	r3, [r3, #4]
 600:	e1a02003 	mov	r2, r3
 604:	e59f0030 	ldr	r0, [pc, #48]	; 63c <print+0x54>
 608:	ebfffffe 	bl	0 <printf>

        printf("&tmp = %p &tmp.a = %p &tmp.b = %p\n", 
 60c:	e59f1024 	ldr	r1, [pc, #36]	; 638 <print+0x50>
 610:	e59f2020 	ldr	r2, [pc, #32]	; 638 <print+0x50>
 614:	e59f3024 	ldr	r3, [pc, #36]	; 640 <print+0x58>
 618:	e59f0024 	ldr	r0, [pc, #36]	; 644 <print+0x5c>
 61c:	ebfffffe 	bl	0 <printf>
                        (unsigned long)(void *)&tmp, 
                        (unsigned long)(void *)&tmp.a,
                        (unsigned long)(void *)&tmp.b);

        printf("sizeof tmp = %d sizeof tmp.a = %d sizeof tmp.b = %d\n", 
 620:	e3a03001 	mov	r3, #1
 624:	e3a02004 	mov	r2, #4
 628:	e3a01008 	mov	r1, #8
 62c:	e59f0014 	ldr	r0, [pc, #20]	; 648 <print+0x60>
 630:	ebfffffe 	bl	0 <printf>
                        sizeof(A),
                        sizeof(int),
                        sizeof(char));
}
 634:	e8bd8800 	pop	{fp, pc}
 638:	00000000 	.word	0x00000000
 63c:	000001a0 	.word	0x000001a0
 640:	00000004 	.word	0x00000004
 644:	000001b8 	.word	0x000001b8
 648:	000001dc 	.word	0x000001dc

0000064c <priBit>:

void priBit(int t)
{
 64c:	e92d4800 	push	{fp, lr}
 650:	e28db004 	add	fp, sp, #4
 654:	e24dd010 	sub	sp, sp, #16
 658:	e50b0010 	str	r0, [fp, #-16]
        int i = 32;
 65c:	e3a03020 	mov	r3, #32
 660:	e50b3008 	str	r3, [fp, #-8]

        printf("t = %d\n", t);
 664:	e51b1010 	ldr	r1, [fp, #-16]
 668:	e59f0048 	ldr	r0, [pc, #72]	; 6b8 <priBit+0x6c>
 66c:	ebfffffe 	bl	0 <printf>
        for (; i > 0; i--)
 670:	ea000009 	b	69c <priBit+0x50>
        {
                printf("%d", (t >> i) & 0x0001);
 674:	e51b2010 	ldr	r2, [fp, #-16]
 678:	e51b3008 	ldr	r3, [fp, #-8]
 67c:	e1a03352 	asr	r3, r2, r3
 680:	e2033001 	and	r3, r3, #1
 684:	e1a01003 	mov	r1, r3
 688:	e59f002c 	ldr	r0, [pc, #44]	; 6bc <priBit+0x70>
 68c:	ebfffffe 	bl	0 <printf>
void priBit(int t)
{
        int i = 32;

        printf("t = %d\n", t);
        for (; i > 0; i--)
 690:	e51b3008 	ldr	r3, [fp, #-8]
 694:	e2433001 	sub	r3, r3, #1
 698:	e50b3008 	str	r3, [fp, #-8]
 69c:	e51b3008 	ldr	r3, [fp, #-8]
 6a0:	e3530000 	cmp	r3, #0
 6a4:	cafffff2 	bgt	674 <priBit+0x28>
        {
                printf("%d", (t >> i) & 0x0001);
        }
        printf("\n");
 6a8:	e3a0000a 	mov	r0, #10
 6ac:	ebfffffe 	bl	0 <putchar>
}
 6b0:	e24bd004 	sub	sp, fp, #4
 6b4:	e8bd8800 	pop	{fp, pc}
 6b8:	00000214 	.word	0x00000214
 6bc:	0000021c 	.word	0x0000021c

000006c0 <_main>:

int _main()
{
 6c0:	e92d4800 	push	{fp, lr}
 6c4:	e28db004 	add	fp, sp, #4
 6c8:	e24dd008 	sub	sp, sp, #8
        int *p = NULL;
 6cc:	e3a03000 	mov	r3, #0
 6d0:	e50b3008 	str	r3, [fp, #-8]

        print();
 6d4:	ebfffffe 	bl	5e8 <print>
        p = (int *)&tmp;
 6d8:	e59f3030 	ldr	r3, [pc, #48]	; 710 <_main+0x50>
 6dc:	e50b3008 	str	r3, [fp, #-8]
        priBit(*p);
 6e0:	e51b3008 	ldr	r3, [fp, #-8]
 6e4:	e5933000 	ldr	r3, [r3]
 6e8:	e1a00003 	mov	r0, r3
 6ec:	ebfffffe 	bl	64c <priBit>
        priBit(*(p + 1));
 6f0:	e51b3008 	ldr	r3, [fp, #-8]
 6f4:	e2833004 	add	r3, r3, #4
 6f8:	e5933000 	ldr	r3, [r3]
 6fc:	e1a00003 	mov	r0, r3
 700:	ebfffffe 	bl	64c <priBit>
}
 704:	e1a00003 	mov	r0, r3
 708:	e24bd004 	sub	sp, fp, #4
 70c:	e8bd8800 	pop	{fp, pc}
 710:	00000000 	.word	0x00000000

00000714 <m_ain>:
        char name[20];
        int num;
};

int m_ain()
{
 714:	e92d4800 	push	{fp, lr}
 718:	e28db004 	add	fp, sp, #4
 71c:	e24dd020 	sub	sp, sp, #32
        void *p = NULL;
 720:	e3a03000 	mov	r3, #0
 724:	e50b3008 	str	r3, [fp, #-8]
        struct stu a={"li main",5};
 728:	e59f3048 	ldr	r3, [pc, #72]	; 778 <m_ain+0x64>
 72c:	e24bc020 	sub	ip, fp, #32
 730:	e1a0e003 	mov	lr, r3
 734:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}
 738:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}
 73c:	e89e0003 	ldm	lr, {r0, r1}
 740:	e88c0003 	stm	ip, {r0, r1}
        p=&a;
 744:	e24b3020 	sub	r3, fp, #32
 748:	e50b3008 	str	r3, [fp, #-8]
        printf(" %s %d  \n",( (struct stu *) p )->name,( (struct stu *) p )->num);
 74c:	e51b1008 	ldr	r1, [fp, #-8]
 750:	e51b3008 	ldr	r3, [fp, #-8]
 754:	e5933014 	ldr	r3, [r3, #20]
 758:	e1a02003 	mov	r2, r3
 75c:	e59f0018 	ldr	r0, [pc, #24]	; 77c <m_ain+0x68>
 760:	ebfffffe 	bl	0 <printf>

		_main();
 764:	ebfffffe 	bl	6c0 <_main>

		return 0;
 768:	e3a03000 	mov	r3, #0
}
 76c:	e1a00003 	mov	r0, r3
 770:	e24bd004 	sub	sp, fp, #4
 774:	e8bd8800 	pop	{fp, pc}
 778:	0000022c 	.word	0x0000022c
 77c:	00000220 	.word	0x00000220

00000780 <main>:

int main()
{
 780:	e92d4800 	push	{fp, lr}
 784:	e28db004 	add	fp, sp, #4
 788:	e24dd028 	sub	sp, sp, #40	; 0x28
	char buf[30];
	
	memset(buf, '0', sizeof(buf));
 78c:	e24b3028 	sub	r3, fp, #40	; 0x28
 790:	e3a0201e 	mov	r2, #30
 794:	e3a01030 	mov	r1, #48	; 0x30
 798:	e1a00003 	mov	r0, r3
 79c:	ebfffffe 	bl	0 <memset>
	strcpy(buf,"ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 7a0:	e24b3028 	sub	r3, fp, #40	; 0x28
 7a4:	e59f20d0 	ldr	r2, [pc, #208]	; 87c <main+0xfc>
 7a8:	e1a0c003 	mov	ip, r3
 7ac:	e1a0e002 	mov	lr, r2
 7b0:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}
 7b4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}
 7b8:	e89e0007 	ldm	lr, {r0, r1, r2}
 7bc:	e8ac0003 	stmia	ip!, {r0, r1}
 7c0:	e1cc20b0 	strh	r2, [ip]
 7c4:	e28cc002 	add	ip, ip, #2
 7c8:	e1a03822 	lsr	r3, r2, #16
 7cc:	e5cc3000 	strb	r3, [ip]
	
	printf("buf length : %d\n", sizeof(buf));	// 30
 7d0:	e3a0101e 	mov	r1, #30
 7d4:	e59f00a4 	ldr	r0, [pc, #164]	; 880 <main+0x100>
 7d8:	ebfffffe 	bl	0 <printf>
	printf("struct length : %d\n", sizeof(struct aaa));	// 16
 7dc:	e3a01010 	mov	r1, #16
 7e0:	e59f009c 	ldr	r0, [pc, #156]	; 884 <main+0x104>
 7e4:	ebfffffe 	bl	0 <printf>
	
	aaa *aa;
	aa = (struct aaa*)buf;
 7e8:	e24b3028 	sub	r3, fp, #40	; 0x28
 7ec:	e50b3008 	str	r3, [fp, #-8]
	
	printf("a1 is %d\n", aa->a1);
 7f0:	e51b3008 	ldr	r3, [fp, #-8]
 7f4:	e5d33000 	ldrb	r3, [r3]
 7f8:	e1a01003 	mov	r1, r3
 7fc:	e59f0084 	ldr	r0, [pc, #132]	; 888 <main+0x108>
 800:	ebfffffe 	bl	0 <printf>
	printf("a2 is %d\n", aa->a2);
 804:	e51b3008 	ldr	r3, [fp, #-8]
 808:	e5d33001 	ldrb	r3, [r3, #1]
 80c:	e1a01003 	mov	r1, r3
 810:	e59f0074 	ldr	r0, [pc, #116]	; 88c <main+0x10c>
 814:	ebfffffe 	bl	0 <printf>
	printf("a3 is %s\n", aa->a3);		// why not overflow, xiaozhi?
 818:	e51b3008 	ldr	r3, [fp, #-8]
 81c:	e2833002 	add	r3, r3, #2
 820:	e1a01003 	mov	r1, r3
 824:	e59f0064 	ldr	r0, [pc, #100]	; 890 <main+0x110>
 828:	ebfffffe 	bl	0 <printf>
	printf("a4 is %s\n", aa->a4);		// ditto
 82c:	e51b3008 	ldr	r3, [fp, #-8]
 830:	e2833008 	add	r3, r3, #8
 834:	e1a01003 	mov	r1, r3
 838:	e59f0054 	ldr	r0, [pc, #84]	; 894 <main+0x114>
 83c:	ebfffffe 	bl	0 <printf>
	printf("a3 is %.6s\n", aa->a3);
 840:	e51b3008 	ldr	r3, [fp, #-8]
 844:	e2833002 	add	r3, r3, #2
 848:	e1a01003 	mov	r1, r3
 84c:	e59f0044 	ldr	r0, [pc, #68]	; 898 <main+0x118>
 850:	ebfffffe 	bl	0 <printf>
	printf("a4 is %.8s\n", aa->a4);
 854:	e51b3008 	ldr	r3, [fp, #-8]
 858:	e2833008 	add	r3, r3, #8
 85c:	e1a01003 	mov	r1, r3
 860:	e59f0034 	ldr	r0, [pc, #52]	; 89c <main+0x11c>
 864:	ebfffffe 	bl	0 <printf>

	saaa();
 868:	ebfffffe 	bl	364 <saaa>
	
	return 0;
 86c:	e3a03000 	mov	r3, #0
}
 870:	e1a00003 	mov	r0, r3
 874:	e24bd004 	sub	sp, fp, #4
 878:	e8bd8800 	pop	{fp, pc}
 87c:	00000244 	.word	0x00000244
 880:	00000260 	.word	0x00000260
 884:	00000274 	.word	0x00000274
 888:	00000288 	.word	0x00000288
 88c:	00000294 	.word	0x00000294
 890:	000002a0 	.word	0x000002a0
 894:	000002ac 	.word	0x000002ac
 898:	000002b8 	.word	0x000002b8
 89c:	000002c4 	.word	0x000002c4
